import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;





public class day230327 {
    static class A {
        protected int value;
        public A(int v) {
            setValue(v);
        }
        public void setValue(int value) {
            this.value = value;
        }
        public int getValue() {
            try{
                value++;
                return value;
            }catch(Exception e) {
                System.out.println(e.toString());
            }finally {
                this.setValue(value);
                System.out.println(value);//22 34
            }
            return value;
        }
    }
    static class B extends A {
        public B() {
            super(5);
            setValue(getValue() - 3);
        }
        public void setValue(int value) {
            super.setValue(2 * value);
        }
    }
    public static void main11(String[] args) {
        System.out.println(new B().getValue());//17
        // 这题需要注意两个点
        // 1. 在父类构造方法中的 setValue 和 get 中的 setValue, 会调用子类的 setValue
        // 2. try 中执行到 return 停住, 去执行 finally,
        //    finally 中改变了 value 的值, value 确实被改变了, 但是 return 的是修改前的,
    }



    // 求最小公倍数
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        long n = (long)a * (long)b;
        int tmp = 0;
        // 辗转相除求最大公约数
        while (b != 0) {
            tmp = a % b;
            a = b;
            b = tmp;
        }
        // 最小公倍数 = 两数乘积 / 最大公约数
        System.out.println(n / a);
    }
    public static void main2(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        for (int i = Math.max(a, b); i <= a*b; i++) {
            if (i % a == 0 && i % b == 0) {
                System.out.println(i);
                return;
            }
        }
    }


    // 两种排序方法
    // 1. 按字母排序, 逐个比较字母, 字母靠后的大
    // 2. 按长度排序, 长的大
    public static void main1(String[] args) throws IOException {

        /*
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        // 因为输入了一行, 上面只接收了一个int, 需要清理剩下的
        scanner.nextLine();
        */

        // 从字符流中读取文本并且缓存
        // 效率更高z`
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(bufferedReader.readLine());// readLine , IOException

        String[] array = new String[n];
        for (int i = 0; i < n; i++) {
            array[i] = bufferedReader.readLine();
        }

        boolean flag1 = sort1(array);
        boolean flag2 = sort2(array);
        if (flag1 && flag2) {
            System.out.println("both");
        } else if (flag1) {
            System.out.println("lexicographically");
        } else if (flag2) {
            System.out.println("lengths");
        } else {
            System.out.println("none");
        }
    }
    // 按字典排序
    public static boolean sort1(String[] array) {
        // 可以直接用 compareTo
        // String 类实现的 compareTo 就是按字典排序的
        /*
        for (int i = 1; i < array.length; i++) {
            if (array[i - 1].compareTo(array[i]) > 0) {
                return false;
            }
        }
        return true;
        */

        for (int i = 1; i < array.length; i++) {
            String str1 = array[i - 1];
            String str2 = array[i];
            int j = 0;
            while (j < str1.length() && j < str2.length() && str1.charAt(j) == str2.charAt(j)) {
                j++;
            }
            // 如果一个字符串遍历到尾了, 另一个还没, 前面字母都相同, 长度长的大
            // 如果 str1 遍历到尾了, str2还没, 符合条件
            // 如果 str1 没遍历完, str2 遍历完了, 不符合条件
            // 如果都没遍历完, 比较字母,
            if (j == str1.length()) {
                // str1 遍历到尾了, 符合条件
                continue;
            }
            if (j == str2.length()) {
                // str1 没遍历完, str2遍历完了, 不符合条件
                return false;
            }
            // 都没遍历完
            if (str1.charAt(j) > str2.charAt(j)) {
                return false;
            }
        }
        return true;
    }
    // 按长度排序
    public static boolean sort2(String[] array) {
        for (int i = 1; i < array.length; i++) {
            String str1 = array[i - 1];
            String str2 = array[i];
            if (str1.length() > str2.length()) {
                return false;
            }
        }
        return true;
    }
}
